package com.changgou.goods.service.impl;

import com.alibaba.fastjson.JSON;
import com.changgou.goods.dao.BrandMapper;
import com.changgou.goods.dao.CategoryMapper;
import com.changgou.goods.dao.SkuMapper;
import com.changgou.goods.dao.SpuMapper;
import com.changgou.goods.pojo.Goods;
import com.changgou.goods.pojo.Sku;
import com.changgou.goods.pojo.Spu;
import com.changgou.goods.service.SpuService;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import entity.IdWorker;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import tk.mybatis.mapper.entity.Example;

import java.util.*;

/****
 * @Author:传智播客
 * @Description:Spu业务层接口实现类
 * @Date 2019/6/14 0:16
 *****/
@Service
public class SpuServiceImpl implements SpuService {

    //注入SpuMapper对象
    @Autowired
    private SpuMapper spuMapper;

    @Autowired
    private SkuMapper skuMapper;

    @Autowired
    private CategoryMapper categoryMapper;

    @Autowired
    private BrandMapper brandMapper;

    @Autowired
    private IdWorker idWorker;

    //注入MQ的模板
    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * @author wzw
     * 恢复数据
     * @Date 23:30 2020/12/11
     * @param spuId
     * @return void
    **/
    @Override
    public void restore(Long spuId) {
        //获取恢复的对象
        Spu spu = spuMapper.selectByPrimaryKey(spuId);
        //检查是否删除的商品
        if (!"1".equals(spu.getIsDelete())){
            //抛异常
            throw new RuntimeException("此商品未删除！");
        }
        //设置删除状态:未删除
        spu.setIsDelete("0");
        //设置审核状态:未审核
        spu.setStatus("0");
        //实现功能:修改
        spuMapper.updateByPrimaryKeySelective(spu);
    }

    /***
     * 逻辑删除
     * @param spuId
     */
    @Override
    public void logicDelete(Long spuId) {
        //查询SPU对象
        Spu spu = spuMapper.selectByPrimaryKey(spuId);
        //检查是否下架的商品
        if (!"0".equals(spu.getIsMarketable())){
            throw new RuntimeException("必须先下架再删除");
        }

        //设置删除状态:逻辑删除
        spu.setIsDelete("1");
        //设置审核状态:未审核
        spu.setStatus("0");
        //实现功能:修改
        spuMapper.updateByPrimaryKeySelective(spu);

    }

    /**
     * @author wzw
     *  批量上架
     * @Date 21:37 2020/12/11
     * @param ids 需要上架的商品ID集合
     * @return void
     **/
    @Override
    public int putMany(Long[] ids,String isMarketable) {
        //1.创建对象
        Spu spu = new Spu();
        //上架
        spu.setIsMarketable(isMarketable);

        //批量修改
        //创建例子
        Example example = new Example(Spu.class);
        //创建模板
        Example.Criteria criteria = example.createCriteria();
        //测试
        System.out.println("测试"+Arrays.asList(ids));
        //添加值id,遍历将数组改为集合
        criteria.andIn("id", Arrays.asList(ids));
        //下架
        criteria.andEqualTo("isMarketable",("0".equals(isMarketable)?"1":"0"));
        //审核通过的
        criteria.andEqualTo("status","1");
        //非删除的
        criteria.andEqualTo("isDelete", "0");
        //返回结果集
        return spuMapper.updateByExampleSelective(spu, example);
    }

    /**
     * @author wzw
     * 上架或下架
     * @Date 20:57 2020/12/11
     * @param spuId
     * @param isMarketable 上下架状态:下架为 0   上架为 1
     * @return void
     **/
    @Override
    public void isShow(Long spuId, String isMarketable) {
        //实现功能:根据id查询spu对象
        Spu spu = spuMapper.selectByPrimaryKey(spuId);
        //设置上下架状态
        spu.setIsMarketable(isMarketable);
        //修改spu对象
        spuMapper.updateByPrimaryKeySelective(spu);

        //上架或者下架是否仅仅只是更新状态
        if ("1".equals(isMarketable)){//上架
            rabbitTemplate.convertAndSend("goods-exchange","goods-routing-key",String.valueOf(spuId));
        }else {//下架
            //2.TODO 将商品从es中删除
            //3.TODO 删除该商品详情静态页面
        }
    }

    /**
     * @author wzw
     * 商品审核
     * @Date 20:41 2020/12/11
     * @param id SPU的id
     * @param status 审核的状态
     * @return void
    **/
    @Override
    public void audit(Long id, String status) {
        //根据id查询对应的SPU对象
        Spu spu = spuMapper.selectByPrimaryKey(id);
        //判断删除状态是否为:1 已删除
        if ("1".equals(spu.getIsDelete())) {
            //如果已删除就抛出异常
            throw new RuntimeException("删除后的商品不能审核");
        }
        //不然就改SPU对象的审核状态:已审核
        spu.setStatus(status);

        //实现功能:修改SPU对象(id上面查询对象的时候已经给有了)
        spuMapper.updateByPrimaryKeySelective(spu);
    }

    /**
     * @author wzw
     *  根据SPU的ID查找SPU以及对应的SKU集合
     * @Date 17:46 2020/12/11
     * @param spuId
     * @return com.changgou.goods.pojo.Goods
    **/
    @Override
    public Goods findGoodsById(Long spuId) {
        //1.查询Spu
        Spu spu = spuMapper.selectByPrimaryKey(spuId);

        //2.查询List<SKu>
        //创建对象
        Sku sku = new Sku();
        //设置查询条件
        sku.setSpuId(spuId);
        //实现功能:查询sku
        List<Sku> skuList = skuMapper.select(sku);

        //3.封装到Goods中
        //创建对象
        Goods goods = new Goods();
        //设置spu
        goods.setSpu(spu);
        //设置skuList
        goods.setSkuList(skuList);

        //返回对象
        return goods;
    }

    /**
     * @author wzw
     * 实现保存
     * @Date 16:21 2020/12/11
     * @param goods
     * @return void
    **/
    @Override
    public void saveOrUpdate(Goods goods) {
        //一.设置SPU的状态
        //1.获取SPU对象
        Spu spu = goods.getSpu();
        //2.如果id为空说明是:添加
        if (spu.getId() == null) {
            //获取自定义id
            long spuId = idWorker.nextId();
            //设置id
            spu.setId(spuId);

            //设置上架状态:未上架
            spu.setIsMarketable("0");
            //设置删除状态:未删除
            spu.setIsDelete("0");
            //设置审核状态:待审核
            spu.setStatus("0");
            //实现功能:添加SPU对象
            spuMapper.insertSelective(spu);
            //打印id
            System.out.println(spu.getId());
        }else {
            //3.否则是:修改
            //因为修改了数据:所以要重新审核:未审核
            spu.setStatus("0");
            //实现功能:修改
            spuMapper.updateByPrimaryKeySelective(spu);

            //4.删除原有的库存列表数据
            //创建对象
            Sku sku = new Sku();
            //封装数据
            sku.setSpuId(spu.getId());
            //实现功能:删除
            skuMapper.delete(sku);

        }

        //二.保存商品对应的库存信息
        //获取对象
        List<Sku> skuList = goods.getSkuList();
        //判断是否有对象
        if (skuList != null && skuList.size() > 0) {
            //循环对象
            for (Sku sku : skuList) {
                //1.设置主键
                //获取自定义id
                long id = idWorker.nextId();
                //设置主键
                sku.setId(id);

                //2.设置商品库存的名称
                //注意:商品库存的名称 = spu名称 + spu副标题  + 规格的value
                //spu名称+副标题
                String name = spu.getName() + " " + spu.getCaption();
                //规格:{"手机屏幕尺寸":"5寸","网络":"移动4G","颜色":"红","机身内存":"16G","存储":"64G","像素":"800万像素"}
                String spec = sku.getSpec();
                //将规格的json格式转为map格式
                Map<String,String> specMap = JSON.parseObject(spec, Map.class);
                //判断是否为空
                if (specMap != null) {
                    //不为空,将map装为Set集合
                    Set<Map.Entry<String, String>> entries = specMap.entrySet();
                    //遍历Set集合
                    for (Map.Entry<String, String> entry : entries) {
                        //将set中的
                        String value = entry.getValue();
                        //加入到name(商品库存的名称)中
                        name += "" + value;
                    }
                }
                //设置商品库存的名称
                sku.setName(name);

                //3.设置录入时间
                sku.setCreateTime(new Date());
                //4.设置更新时间
                sku.setUpdateTime(new Date());
                //5.设置商品id
                sku.setSpuId(spu.getId());
                //6.设置三级分类id(还有一二级)
                sku.setCategoryId(spu.getCategory3Id());
                //7.设置分类名称
                //实现查询功能,获取名称
                String categoryName = categoryMapper.selectByPrimaryKey(spu.getCategory3Id()).getName();
                //添加名称
                sku.setCategoryName(categoryName);

                //8.设置品牌名称(实现功能:查询品牌对象,获取名称)
                sku.setBrandName(brandMapper.selectByPrimaryKey(spu.getBrandId()).getName());

                //9.设置商品状态 1-正常，2-下架，3-删除
                sku.setStatus("1");

                //实现功能:添加商品到数据库中
                skuMapper.insertSelective(sku);

                //测试用的id,因为表中数据太多,很难找
                System.out.println(sku.getId());

            }
        }
    }

    /**
     * Spu条件+分页查询
     * @param spu 查询条件
     * @param page 页码
     * @param size 页大小
     * @return 分页结果
     */
    @Override
    public PageInfo<Spu> findPage(Spu spu, int page, int size){
        //分页
        PageHelper.startPage(page,size);
        //搜索条件构建
        Example example = createExample(spu);
        //执行搜索
        return new PageInfo<Spu>(spuMapper.selectByExample(example));
    }

    /**
     * Spu分页查询
     * @param page
     * @param size
     * @return
     */
    @Override
    public PageInfo<Spu> findPage(int page, int size){
        //静态分页
        PageHelper.startPage(page,size);
        //分页查询
        return new PageInfo<Spu>(spuMapper.selectAll());
    }

    /**
     * Spu条件查询
     * @param spu
     * @return
     */
    @Override
    public List<Spu> findList(Spu spu){
        //构建查询条件
        Example example = createExample(spu);
        //根据构建的条件查询数据
        return spuMapper.selectByExample(example);
    }


    /**
     * Spu构建查询对象
     * @param spu
     * @return
     */
    public Example createExample(Spu spu){
        Example example=new Example(Spu.class);
        Example.Criteria criteria = example.createCriteria();
        if(spu!=null){
            // 主键
            if(!StringUtils.isEmpty(spu.getId())){
                    criteria.andEqualTo("id",spu.getId());
            }
            // 货号
            if(!StringUtils.isEmpty(spu.getSn())){
                    criteria.andEqualTo("sn",spu.getSn());
            }
            // SPU名
            if(!StringUtils.isEmpty(spu.getName())){
                    criteria.andLike("name","%"+spu.getName()+"%");
            }
            // 副标题
            if(!StringUtils.isEmpty(spu.getCaption())){
                    criteria.andEqualTo("caption",spu.getCaption());
            }
            // 品牌ID
            if(!StringUtils.isEmpty(spu.getBrandId())){
                    criteria.andEqualTo("brandId",spu.getBrandId());
            }
            // 一级分类
            if(!StringUtils.isEmpty(spu.getCategory1Id())){
                    criteria.andEqualTo("category1Id",spu.getCategory1Id());
            }
            // 二级分类
            if(!StringUtils.isEmpty(spu.getCategory2Id())){
                    criteria.andEqualTo("category2Id",spu.getCategory2Id());
            }
            // 三级分类
            if(!StringUtils.isEmpty(spu.getCategory3Id())){
                    criteria.andEqualTo("category3Id",spu.getCategory3Id());
            }
            // 模板ID
            if(!StringUtils.isEmpty(spu.getTemplateId())){
                    criteria.andEqualTo("templateId",spu.getTemplateId());
            }
            // 运费模板id
            if(!StringUtils.isEmpty(spu.getFreightId())){
                    criteria.andEqualTo("freightId",spu.getFreightId());
            }
            // 图片
            if(!StringUtils.isEmpty(spu.getImage())){
                    criteria.andEqualTo("image",spu.getImage());
            }
            // 图片列表
            if(!StringUtils.isEmpty(spu.getImages())){
                    criteria.andEqualTo("images",spu.getImages());
            }
            // 售后服务
            if(!StringUtils.isEmpty(spu.getSaleService())){
                    criteria.andEqualTo("saleService",spu.getSaleService());
            }
            // 介绍
            if(!StringUtils.isEmpty(spu.getIntroduction())){
                    criteria.andEqualTo("introduction",spu.getIntroduction());
            }
            // 规格列表
            if(!StringUtils.isEmpty(spu.getSpecItems())){
                    criteria.andEqualTo("specItems",spu.getSpecItems());
            }
            // 参数列表
            if(!StringUtils.isEmpty(spu.getParaItems())){
                    criteria.andEqualTo("paraItems",spu.getParaItems());
            }
            // 销量
            if(!StringUtils.isEmpty(spu.getSaleNum())){
                    criteria.andEqualTo("saleNum",spu.getSaleNum());
            }
            // 评论数
            if(!StringUtils.isEmpty(spu.getCommentNum())){
                    criteria.andEqualTo("commentNum",spu.getCommentNum());
            }
            // 是否上架,0已下架，1已上架
            if(!StringUtils.isEmpty(spu.getIsMarketable())){
                    criteria.andEqualTo("isMarketable",spu.getIsMarketable());
            }
            // 是否启用规格
            if(!StringUtils.isEmpty(spu.getIsEnableSpec())){
                    criteria.andEqualTo("isEnableSpec",spu.getIsEnableSpec());
            }
            // 是否删除,0:未删除，1：已删除
            if(!StringUtils.isEmpty(spu.getIsDelete())){
                    criteria.andEqualTo("isDelete",spu.getIsDelete());
            }
            // 审核状态，0：未审核，1：已审核，2：审核不通过
            if(!StringUtils.isEmpty(spu.getStatus())){
                    criteria.andEqualTo("status",spu.getStatus());
            }
        }
        return example;
    }

    /**
     * 删除
     * @param id
     */
    @Override
    public void delete(Long id){
        //获取要删除的对象
        Spu spu = spuMapper.selectByPrimaryKey(id);
        //检查是否逻辑删除,必须要先逻辑删除后,才能物理删除
        if (!"1".equals(spu.getIsDelete())){
            throw new RuntimeException("此商品不能删除！没逻辑删除");
        }
        //物理删除
        spuMapper.deleteByPrimaryKey(id);
    }

    /**
     * 修改Spu
     * @param spu
     */
    @Override
    public void update(Spu spu){
        spuMapper.updateByPrimaryKey(spu);
    }

    /**
     * 增加Spu
     * @param spu
     */
    @Override
    public void add(Spu spu){
        spuMapper.insert(spu);
    }

    /**
     * 根据ID查询Spu
     * @param id
     * @return
     */
    @Override
    public Spu findById(Long id){
        return  spuMapper.selectByPrimaryKey(id);
    }

    /**
     * 查询Spu全部数据
     * @return
     */
    @Override
    public List<Spu> findAll() {
        return spuMapper.selectAll();
    }
}
